# 语音对话电脑控制助手 - 主程序入口
import os
import sys
import time
import traceback
import subprocess
import logging
import sys
from typing import Dict, Any, Optional

# 配置日志记录
import os
from datetime import datetime

# 创建日志目录
log_dir = "logs"
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# 添加直接文件写入以确保日志记录
def log_to_file(message):
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    with open("direct_log.txt", "a", encoding="utf-8") as f:
        f.write(f"[{timestamp}] {message}\n")

# 记录启动信息
log_to_file("程序开始启动...")

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f"logs/assistant_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log", encoding='utf-8'),
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger("VoiceAssistant")

# 再次记录以确保日志初始化成功
log_to_file("日志系统初始化完成")

# 导入模块
try:
    from voice_recognition import VoiceRecognizer, text_to_speech
    from config import API_KEY, USE_LOCAL_LLM, LLM_MODEL, WAKE_WORD
    # 导入语音命令处理器
    from voice_command_processor import VoiceCommandProcessor
    command_processor = VoiceCommandProcessor()
    
    # 导入命令解析器
    try:
        from llm_interface import LLMInterface, SimpleCommandParser
        logger.info("成功导入命令解析器模块")
    except ImportError as e:
        logger.warning(f"无法导入LLM接口模块: {e}，将尝试使用本地命令解析器")
        
        # 定义简单命令解析器作为备用
        class SimpleCommandParser:
            """简单命令解析器，用于基础命令识别"""
            
            def __init__(self):
                # 预定义的命令映射
                self.commands = {
                    "打开": "open_app",
                    "关闭": "close_app",
                    "创建": "create_folder",
                    "查看": "list_files",
                    "搜索": "search_files",
                    "音量": "volume_up",
                    "静音": "mute",
                    "亮度": "brightness_up",
                    "关机": "shutdown",
                    "重启": "restart",
                    "睡眠": "sleep"
                }
            
            def process_query(self, query):
                """处理查询，返回命令和参数"""
                query = query.lower()
                
                for keyword, command in self.commands.items():
                    if keyword in query:
                        # 提取参数
                        params = self._extract_params(query, keyword, command)
                        return {
                            "command": command,
                            "params": params,
                            "response": f"正在执行{keyword}操作"
                        }
                
                return {
                    "command": "other",
                    "params": {},
                    "response": "无法识别您的命令"
                }
            
            def _extract_params(self, query, keyword, command):
                """提取命令参数"""
                params = {}
                
                if command == "open_app":
                    # 提取应用名称
                    app_names = ["chrome", "记事本", "命令提示符", "计算器"]
                    for app in app_names:
                        if app in query:
                            params["app_name"] = app
                            break
                elif command == "close_app":
                    # 提取要关闭的应用名称
                    app_names = ["chrome", "记事本", "命令提示符"]
                    for app in app_names:
                        if app in query:
                            params["app_name"] = app
                            break
                elif command == "create_folder":
                    # 提取文件夹名称
                    try:
                        # 简单的参数提取逻辑
                        parts = query.split("名为")
                        if len(parts) > 1:
                            params["folder_name"] = parts[1].strip()
                    except:
                        pass
                elif command == "list_files":
                    params["path"] = "."
                elif command == "search_files":
                    # 提取搜索关键字
                    try:
                        parts = query.split("搜索")
                        if len(parts) > 1:
                            params["keyword"] = parts[1].strip()
                    except:
                        pass
                
                return params
                
        LLMInterface = SimpleCommandParser  # 作为备用
except Exception as e:
    logger.error(f"导入核心模块时出错: {str(e)}")
    print("❌ 启动失败: 缺少必要的模块")
    sys.exit(1)

class VoiceAssistant:
    def __init__(self):
        # 初始化各个组件
        self.voice_recognizer = VoiceRecognizer()
        # 设置语音合成函数，避免循环导入
        self.voice_recognizer.set_text_to_speech(text_to_speech)
        self.system_controller = SystemController()
        # 初始化语音命令处理器
        self.command_processor = command_processor
        
        # 根据是否有API密钥选择合适的命令解析器
        if API_KEY and API_KEY != "your_api_key_here":
            self.command_parser = LLMInterface()
            print("🔄 系统配置: 使用OpenAI API进行命令解析 - 支持自然语言交互")
        else:
            self.command_parser = SimpleCommandParser()
            print("🔄 系统配置: 使用本地简单命令解析器 - 支持基础指令")
            if not API_KEY or API_KEY == "your_api_key_here":
                print("💡 提示: 未配置OpenAI API密钥，功能可能受限。")
                print("📝 您仍可使用预设的基础命令，如'打开Chrome'、'减小音量'等。")
                print("⚙️  要获得更智能的自然语言理解，请在config.py中设置真实的API_KEY。")
        
        # 设置语音识别回调
        self.voice_recognizer.set_callback(self.handle_voice_command)
        
        # 初始化状态
        self.running = False
        self.confirming_command = None  # 用于存储需要确认的命令
        self.voice_history = []
        self.is_mute = False
        
        # 初始化组件
        self._initialize_components()
    
    def _initialize_components(self):
        """初始化系统组件"""
        print("🔧 正在初始化系统组件...")
        
        # 设置语音命令处理器的系统组件
        if self.command_processor:
            self.command_processor.set_components({
                "system_controller": self.system_controller,
                "tts_engine": None,  # 可以根据需要设置
                "recognizer": None   # 可以根据需要设置
            })
            print("✅ 语音命令处理器组件已配置")
        
        # 运行系统诊断
        self.run_diagnostic()
    
    def run_diagnostic(self):
        """运行系统诊断"""
        print("\n🔍 系统诊断报告:")
        
        # 检查语音命令处理器
        voice_processor_status = "✅ 正常" if self.command_processor else "❌ 未加载"
        print(f"语音命令处理器: {voice_processor_status}")
        
        # 检查CR模块
        cr_status = "❌ 未加载"
        try:
            import system_controller
            if hasattr(system_controller, 'CR_MODULE_AVAILABLE') and system_controller.CR_MODULE_AVAILABLE:
                cr_status = "✅ 正常"
            else:
                # 尝试直接检查cr_module的可用性
                import cr_module
                if hasattr(cr_module, 'is_available') and cr_module.is_available():
                    cr_status = "✅ 正常"
                elif hasattr(cr_module, 'screen_recognizer'):
                    # 如果有screen_recognizer实例，检查Tesseract是否可用
                    if hasattr(cr_module.screen_recognizer, 'tesseract_available') and cr_module.screen_recognizer.tesseract_available:
                        cr_status = "✅ 正常"
                    else:
                        cr_status = "⚠️  部分功能可用（缺少Tesseract）"
        except ImportError:
            pass
        print(f"屏幕内容识别模块: {cr_status}")
        
        # 检查工作流管理模块
        workflow_status = "❌ 未加载"
        try:
            import system_controller
            if hasattr(system_controller, 'WORKFLOW_AVAILABLE') and system_controller.WORKFLOW_AVAILABLE:
                workflow_status = "✅ 正常"
            else:
                # 尝试直接检查workflow_manager的状态
                import workflow_manager
                if hasattr(workflow_manager, 'workflow_manager') and workflow_manager.workflow_manager:
                    workflow_status = "✅ 正常"
        except ImportError:
            pass
        print(f"工作流管理模块: {workflow_status}")
        
        # 检查大模型增强模块
        model_status = "❌ 未加载"
        try:
            import system_controller
            if hasattr(system_controller, 'MODEL_ENHANCER_AVAILABLE') and system_controller.MODEL_ENHANCER_AVAILABLE:
                model_status = "✅ 正常"
            else:
                # 尝试直接导入检查
                import model_enhancer
                model_status = "✅ 正常"
        except ImportError:
            pass
        print(f"大模型增强模块: {model_status}")
        
        print()
    
    def handle_voice_command(self, command_text):
        """处理识别到的语音命令，支持命令确认、对话上下文和语音识别优化"""
        print(f"🔊 接收到命令: {command_text}")
        cmd_lower = command_text.lower()
        
        # 记录命令历史
        self.voice_history.append({
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "command": command_text
        })
        
        # 限制历史记录数量
        if len(self.voice_history) > 100:
            self.voice_history = self.voice_history[-100:]
        
        # 处理命令确认
        if self.confirming_command:
            # 检查用户是否确认
            if any(word in cmd_lower for word in ["是", "是的", "确认", "对", "对的", "没错", "好"]):
                # 用户确认执行命令
                self._execute_confirmed_command()
            elif any(word in cmd_lower for word in ["否", "不是", "不", "取消", "算了", "重来"]):
                # 用户取消命令
                text_to_speech("已取消操作")
                self.confirming_command = None
            else:
                # 未理解确认内容
                text_to_speech("请说'是'或'否'来确认您的命令")
            return
        
        # 特殊命令处理
        if any(keyword in cmd_lower for keyword in ["退出", "停止", "结束", "关闭程序"]):
            self.stop()
            return
        
        # 静音模式控制
        if "静音" in cmd_lower and "模式" in cmd_lower:
            self.is_mute = not self.is_mute
            status = "已开启" if self.is_mute else "已关闭"
            print(f"🔇 静音模式{status}")
            if not self.is_mute:
                text_to_speech(f"静音模式{status}")
            return
        
        # 检查是否是清除对话历史命令
        if any(keyword in cmd_lower for keyword in ["清除对话历史", "重置对话", "忘记之前的对话", "清除历史"]):
            if hasattr(self.command_parser, 'clear_conversation'):
                result = self.command_parser.clear_conversation()
                text_to_speech(result.get("response", "对话历史已清除"))
                return
        
        # 使用语音命令处理器处理命令（优先）
        if self.command_processor:
            processor_result = self.command_processor.process_voice_command(command_text)
            if processor_result and "error" not in processor_result:
                # 命令处理器已成功处理命令
                if processor_result.get("response"):
                    print(f"\n💬 响应: {processor_result['response']}")
                    if not self.is_mute:
                        text_to_speech(processor_result['response'])
                return
        
        # 增强的命令处理逻辑
        enhanced_result = self.enhanced_command_processing(command_text)
        if enhanced_result:
            text_to_speech(enhanced_result)
            return
        
        # 使用命令解析器处理
        try:
            # 解析命令，传递is_speech=True参数
            result = self.command_parser.process_query(command_text, is_speech=True)
            
            # 检查是否需要用户确认（低置信度的语音命令）
            if result.get("need_confirmation", False):
                # 保存待确认的命令
                self.confirming_command = result
                # 播放确认提示
                print(f"🤔 需要确认: {result['response']}")
                if not self.is_mute:
                    text_to_speech(result["response"])
                return
            
            # 获取解析结果，兼容不同的输出格式
            command = result.get("command")
            # SimpleCommandParser返回params，LLMInterface可能返回parameters
            parameters = result.get("params", {}) or result.get("parameters", {})
            response_text = result.get("response", "正在处理您的请求...")
            
            # 输出响应
            print(f"💬 响应: {response_text}")
            if not self.is_mute:
                text_to_speech(response_text)
            
            # 如果识别到具体命令，执行系统操作
            if command and command != "other":
                    execute_result = self.system_controller.execute_command(command, parameters)
                    print(f"✅ 执行结果: {execute_result}")
                    # 对于重要的执行结果进行语音反馈
                    if execute_result and not self.is_mute:
                        # 对返回信息进行简短处理，更适合语音播报
                        if len(execute_result) > 100:
                            execute_result = execute_result[:100] + "..."
                        # 只播报有意义的结果
                        if any(keyword in execute_result for keyword in ["成功", "失败", "找到", "未找到", "已", "完成", "无法", "错误"]):
                            text_to_speech(execute_result)
        
        except Exception as e:
            error_msg = f"❌ 处理命令时出错: {str(e)}"
            print(error_msg)
            print(traceback.format_exc())
            if not self.is_mute:
                text_to_speech("抱歉，处理您的命令时出现错误")
    
    def _execute_confirmed_command(self):
        """执行用户确认的命令"""
        if not self.confirming_command:
            return
        
        result = self.confirming_command
        command = result.get("command")
        parameters = result.get("parameters", {})
        
        print(f"✅ 执行确认的命令: {command}")
        
        try:
            # 执行命令
            execute_result = self.system_controller.execute_command(command, parameters)
            print(f"✅ 执行结果: {execute_result}")
            
            # 语音反馈执行结果
            success_msg = "操作已完成"
            if execute_result:
                if len(execute_result) > 100:
                    execute_result = execute_result[:100] + "..."
                success_msg = execute_result
            
            text_to_speech(success_msg)
            
        except Exception as e:
            error_msg = f"执行命令时出错: {str(e)}"
            print(error_msg)
            text_to_speech("抱歉，执行命令时出现错误")
        finally:
            # 清除确认状态
            self.confirming_command = None
    
    def show_tesseract_installation_guide(self):
        """
        显示Tesseract OCR安装和配置指南
        """
        print("\n📋 Tesseract OCR安装指南")
        print("===============================")
        print("1. 下载Tesseract OCR安装包:")
        print("   - 官方推荐的Windows版本: https://github.com/UB-Mannheim/tesseract/wiki")
        print("   - 选择最新的64位安装程序 (tesseract-ocr-w64-setup-x.x.x.exe)")
        print("\n2. 安装Tesseract OCR:")
        print("   - 运行安装程序")
        print("   - 默认安装路径通常是: C:\\Program Files\\Tesseract-OCR")
        print("   - 建议保持默认路径以方便自动配置")
        print("   - 安装时确保选择'Additional language data'以支持多语言识别")
        print("\n3. 配置环境变量:")
        print("   - 将Tesseract安装目录添加到系统PATH环境变量中")
        print("   - 或使用以下Python代码手动设置路径:")
        print("     ```python")
        print("     from cr_module import set_tesseract_path")
        print("     set_tesseract_path('C:\\\\Program Files\\\\Tesseract-OCR\\\\tesseract.exe')")
        print("     ```")
        print("\n4. 验证安装:")
        print("   - 安装完成后，重启Python程序或IDE")
        print("   - 运行诊断命令检查Tesseract是否可用")
        print("   - 模块会自动尝试检测已安装的Tesseract")
        print("\n5. 可选：安装语言数据包以支持中文识别")
        print("   - 确保安装时选择了中文语言包")
        print("   - 或从https://github.com/tesseract-ocr/tessdata下载chi_sim.traineddata文件")
        print("   - 将下载的文件复制到Tesseract安装目录下的tessdata文件夹中")
        print("===============================")
        print("\n📌 提示: 您也可以运行 'python install_tesseract.py' 尝试自动下载并安装Tesseract OCR")
    
    def test_ocr_functionality(self):
        """
        测试OCR功能是否正常工作
        """
        print("\n🔍 测试OCR功能")
        
        # 尝试导入cr_module
        try:
            import cr_module
            # 检查是否有screen_recognizer实例
            if hasattr(cr_module, 'screen_recognizer'):
                recognizer = cr_module.screen_recognizer
            else:
                # 如果没有实例，尝试创建一个
                from cr_module import ScreenContentRecognizer
                recognizer = ScreenContentRecognizer()
            
            # 检查Tesseract是否可用
            if not hasattr(recognizer, 'tesseract_available') or not recognizer.tesseract_available:
                print("❌ Tesseract OCR不可用")
                print("请按照安装指南安装Tesseract OCR")
                self.show_tesseract_installation_guide()
                return False
            
            try:
                print("📸 正在截取屏幕并测试文本识别...")
                # 截取屏幕的一小部分进行测试
                import pyautogui
                screenshot = pyautogui.screenshot(region=(0, 0, 300, 200))
                
                # 将PIL图像转换为numpy数组以便OCR处理
                import numpy as np
                img_array = np.array(screenshot)
                
                # 使用Tesseract提取文本
                import pytesseract
                text = pytesseract.image_to_string(img_array, lang='chi_sim+eng')
                
                if text.strip():
                    print(f"✅ OCR测试成功!")
                    print(f"识别到的文本: {text[:100]}..." if len(text) > 100 else f"识别到的文本: {text.strip()}")
                    return True
                else:
                    print("⚠️ OCR测试未识别到文本")
                    print("请确保测试区域包含可见文本")
                    return False
                    
            except ImportError as e:
                print(f"❌ 缺少依赖库: {str(e)}")
                return False
            except Exception as e:
                print(f"❌ OCR测试失败: {str(e)}")
                return False
                
        except ImportError:
            print("❌ 屏幕内容识别模块未加载")
            return False
    
    def check_module_details(self):
        """
        显示各模块的详细状态信息
        """
        print("\n📊 模块详细状态信息")
        print("===============================")
        
        # 显示屏幕内容识别模块状态
        print("\n📱 屏幕内容识别模块:")
        try:
            import cr_module
            # 检查是否有get_module_status函数
            if hasattr(cr_module, 'get_module_status'):
                cr_status = cr_module.get_module_status()
                print(f"   - pyautogui: {'✅ 可用' if cr_status['pyautogui_available'] else '❌ 不可用'}")
                print(f"   - numpy: {'✅ 可用' if cr_status['numpy_available'] else '❌ 不可用'}")
                print(f"   - OpenCV: {'✅ 可用' if cr_status['opencv_available'] else '❌ 不可用'}")
                print(f"   - Tesseract OCR: {'✅ 可用' if cr_status['tesseract_available'] else '❌ 不可用'}")
                if cr_status.get('tesseract_path'):
                    print(f"   - Tesseract路径: {cr_status['tesseract_path']}")
                print(f"   - 截图功能: {'✅ 可用' if cr_status['can_screenshot'] else '❌ 不可用'}")
                print(f"   - 图像处理: {'✅ 可用' if cr_status['can_process_images'] else '❌ 不可用'}")
                print(f"   - 文本识别: {'✅ 可用' if cr_status['can_ocr'] else '❌ 不可用'}")
            else:
                # 尝试直接获取状态
                if hasattr(cr_module, 'PYAUTOGUI_AVAILABLE'):
                    print(f"   - pyautogui: {'✅ 可用' if cr_module.PYAUTOGUI_AVAILABLE else '❌ 不可用'}")
                if hasattr(cr_module, 'NUMPY_AVAILABLE'):
                    print(f"   - numpy: {'✅ 可用' if cr_module.NUMPY_AVAILABLE else '❌ 不可用'}")
                if hasattr(cr_module, 'CV2_AVAILABLE'):
                    print(f"   - OpenCV: {'✅ 可用' if cr_module.CV2_AVAILABLE else '❌ 不可用'}")
                if hasattr(cr_module, 'TESSERACT_AVAILABLE'):
                    print(f"   - Tesseract OCR: {'✅ 可用' if cr_module.TESSERACT_AVAILABLE else '❌ 不可用'}")
        except ImportError:
            print("   - 模块未加载")
        
        # 显示工作流管理模块状态
        print("\n⚙️ 工作流管理模块:")
        try:
            import workflow_manager
            if hasattr(workflow_manager, 'keyboard_available'):
                print(f"   - 鼠标控制: {'✅ 可用' if workflow_manager.mouse_available else '❌ 不可用'}")
                print(f"   - 键盘控制: {'✅ 可用' if workflow_manager.keyboard_available else '❌ 不可用'}")
                print(f"   - 键盘钩子: {'✅ 可用' if workflow_manager.keyboard_hook_available else '❌ 不可用'}")
        except ImportError:
            print("   - 模块未加载")
        
        # 显示大模型增强模块状态
        print("\n🤖 大模型增强模块:")
        try:
            import system_controller
            if hasattr(system_controller, 'MODEL_ENHANCER_AVAILABLE'):
                print(f"   - 状态: {'✅ 可用' if system_controller.MODEL_ENHANCER_AVAILABLE else '❌ 不可用'}")
            else:
                # 尝试直接导入检查
                import model_enhancer
                print(f"   - 状态: ✅ 可用")
        except ImportError:
            print(f"   - 状态: ❌ 未加载")
        
        print("===============================")
    
    def run_wizard(self):
        """
        运行配置向导，帮助用户设置和测试系统
        """
        print("\n🧙‍♂️ 语音助手配置向导")
        print("===============================")
        
        # 运行诊断
        print("\n1. 运行系统诊断...")
        self.run_diagnostic()
        
        # 显示模块详情
        print("\n2. 检查模块详细状态...")
        self.check_module_details()
        
        # 检查Tesseract OCR
        try:
            import cr_module
            if hasattr(cr_module, 'TESSERACT_AVAILABLE') and not cr_module.TESSERACT_AVAILABLE:
                print("\n3. Tesseract OCR未安装或配置")
                print("   为了启用文本识别功能，建议安装Tesseract OCR")
                self.show_tesseract_installation_guide()
        except ImportError:
            pass
        
        # 测试OCR（如果已安装）
        print("\n4. 测试OCR功能（如果已安装）...")
        self.test_ocr_functionality()
        
        print("\n===============================")
        print("✅ 配置向导完成")
        print("系统已准备就绪，可以开始使用语音助手了！")
        print("输入 'python -m main' 启动语音助手")
        print("或使用语音命令 '启动向导' 再次运行此配置向导")
        print("===============================")
    
    def enhanced_command_processing(self, command):
        """增强的命令处理逻辑"""
        cmd_lower = command.lower()
        
        # 添加更多实用命令
        if "截图" in cmd_lower or "截屏" in cmd_lower:
            try:
                import pyautogui
                import time
                print("📷 准备截图...")
                text_to_speech("准备截图")
                time.sleep(1)  # 给用户时间准备
                screenshot = pyautogui.screenshot()
                filename = f"screenshot_{time.strftime('%Y%m%d_%H%M%S')}.png"
                screenshot.save(filename)
                return f"截图已保存到 {filename}"
            except ImportError:
                print("⚠️  缺少pyautogui库")
                return "截图功能需要安装pyautogui库，请运行pip install pyautogui"
        
        if "天气" in cmd_lower or "温度" in cmd_lower:
            return "目前天气功能需要网络连接，请稍后添加API密钥以启用"
        
        if "计算" in cmd_lower:
            try:
                # 简单的数学计算功能
                import re
                # 提取计算表达式
                calc_match = re.search(r'计算\s*(.+?)', cmd_lower)
                if calc_match:
                    expression = calc_match.group(1)
                    # 过滤安全的计算表达式
                    safe_chars = re.compile(r'^[0-9\s+\-*/().]+$')
                    if safe_chars.match(expression):
                        try:
                            # 使用eval计算结果，已通过正则过滤确保安全
                            result = eval(expression)
                            return f"计算结果: {result}"
                        except Exception:
                            return "无法计算，请检查表达式"
                    else:
                        return "不支持的计算表达式"
            except Exception as e:
                print(f"计算功能错误: {e}")
        
        # 添加系统诊断命令
        if any(keyword in cmd_lower for keyword in ["诊断", "检查", "测试", "状态"]):
            self.run_diagnostic()
            return "系统诊断已完成"
        
        # 添加Tesseract OCR安装指南命令
        if any(keyword in cmd_lower for keyword in ["ocr安装", "tesseract", "文本识别"]):
            self.show_tesseract_installation_guide()
            return "已显示Tesseract OCR安装指南"
        
        # 添加测试OCR功能命令
        if "测试ocr" in cmd_lower or "测试文本识别" in cmd_lower:
            success = self.test_ocr_functionality()
            return "OCR测试已完成" if success else "OCR测试失败，请检查安装"
        
        # 添加配置向导命令
        if any(keyword in cmd_lower for keyword in ["向导", "配置", "设置", "初始化"]):
            self.run_wizard()
            return "配置向导已完成"
        
        return None
        
        if "音乐" in cmd_lower or "播放" in cmd_lower:
            return "音乐播放功能已准备就绪，请说出您想播放的音乐"
        
        if "提醒" in cmd_lower:
            return "提醒功能已准备就绪，请设置提醒内容和时间"
        
        return None
    
    def start(self):
        """启动语音助手"""
        print("\n🎉 语音对话电脑控制助手已启动 🎉")
        print(f"📢 唤醒方式: 请说 '{WAKE_WORD}' 唤醒我")
        print(f"👁️  监听状态: 系统将在识别到唤醒词后显示提示，让您知道何时在听")
        print(f"🔊 示例命令:")
        print(f"  - 打开应用: 电脑，打开Chrome/电脑，打开记事本")
        print(f"  - 系统控制: 电脑，增大音量/电脑，静音")
        print(f"  - 文件操作: 电脑，查看当前目录")
        print(f"  - 信息查询: 电脑，查看系统信息")
        print(f"  - 增强功能: 电脑，截图/电脑，计算 2加3乘4")
        print(f"🚪 退出程序: 请说 '退出' 或 '停止'")
        print(f"💡 提示: 输入 Ctrl+C 切换到命令行模式")
        print("==============================\n")
        
        # 显示高级功能提示
        print("💡 提示：除了基本命令外，您现在可以使用更复杂的自然语言指令，如'帮我搜索桌面上的文档文件'或'分析当前屏幕内容并总结重点'")
        
        # 欢迎语音
        welcome_message = "语音助手已启动。我是您的智能电脑助手，会通过声音和屏幕提示让您知道我何时在听。请说电脑唤醒我，然后告诉我您想要做什么。"
        if not self.is_mute:
            text_to_speech(welcome_message)
        
        # 开始持续监听
        self.running = True
        self.voice_recognizer.start_listening()
        
        # 主循环
        try:
            while self.running:
                # 可以在这里添加其他逻辑
                time.sleep(1)
        except KeyboardInterrupt:
            print("\n🔄 检测到中断信号，切换到命令行模式...")
            # 切换到命令行模式
            cli = CommandLineInterface()
            cli.start()
        finally:
            self.stop()
    
    def stop(self):
        """停止语音助手"""
        print("\n正在停止语音助手...")
        self.running = False
        self.voice_recognizer.stop_listening()
        text_to_speech("语音助手已停止")
        print("程序已退出")
        sys.exit(0)

# 命令行交互模式
class CommandLineInterface:
    def __init__(self):
        self.system_controller = SystemController()
        
        # 根据是否有API密钥选择合适的命令解析器
        if API_KEY and API_KEY != "your_api_key_here":
            self.command_parser = LLMInterface()
            print("🔄 系统配置: 使用OpenAI API进行命令解析 - 支持自然语言交互")
        else:
            self.command_parser = SimpleCommandParser()
            print("🔄 系统配置: 使用本地简单命令解析器 - 支持基础指令")
    
    def start(self):
        """启动命令行交互"""
        print("\n=== 命令行控制模式 ===")
        print("输入命令，或输入 'exit' 退出")
        print("输入 'help' 查看帮助")
        print("输入 'voice' 切换到语音模式")
        print("====================")
        
        while True:
            try:
                command_text = input("\n请输入命令: ").strip()
                
                if command_text.lower() in ["exit", "quit", "退出"]:
                    print("👋 程序已退出")
                    break
                
                elif command_text.lower() in ["help", "帮助"]:
                    self.show_help()
                    continue
                
                elif command_text.lower() in ["system", "系统信息"]:
                    info = self.system_controller.get_system_info()
                    print(info)
                    continue
                    
                elif command_text.lower() == "voice":
                    print("🔄 切换到语音模式...")
                    # 启动语音模式
                    from main import VoiceAssistant
                    assistant = VoiceAssistant()
                    assistant.start()
                    break
                
                # 增强的命令处理逻辑
                enhanced_result = self.enhanced_command_processing(command_text)
                if enhanced_result:
                    print(f"\n💬 结果: {enhanced_result}")
                    continue
                
                # 处理命令
                result = self.command_parser.process_query(command_text)
                
                # 显示响应
                print(f"\n💬 响应: {result.get('response', '')}")
                
                # 执行系统命令
                command = result.get("command")
                # 兼容SimpleCommandParser返回的params和LLMInterface返回的parameters
                parameters = result.get("params", {}) or result.get("parameters", {})
                
                if command and command != "other":
                    execute_result = self.system_controller.execute_command(command, parameters)
                    print(f"✅ 执行结果: {execute_result}")
                    
                    # 增强对系统信息、文件搜索等输出的支持
                    if command == "system_info" or command == "list_files" or command == "search_files":
                        # 这些命令的执行结果已经很详细，不需要额外处理
                        pass
                
            except Exception as e:
                print(f"❌ 错误: {str(e)}")
    
    def enhanced_command_processing(self, command):
        """增强的命令处理逻辑"""
        cmd_lower = command.lower()
        
        # 添加更多实用命令
        if "截图" in cmd_lower or "截屏" in cmd_lower:
            try:
                import pyautogui
                import time
                print("📷 准备截图...")
                time.sleep(1)  # 给用户时间准备
                screenshot = pyautogui.screenshot()
                filename = f"screenshot_{time.strftime('%Y%m%d_%H%M%S')}.png"
                screenshot.save(filename)
                return f"截图已保存到 {filename}"
            except ImportError:
                return "截图功能需要安装pyautogui库，请运行pip install pyautogui"
        
        if "计算" in cmd_lower:
            try:
                # 简单的计算表达式提取
                import re
                expr = re.search(r'计算\s*(.+)', cmd_lower)
                if expr:
                    calc_expr = expr.group(1)
                    # 替换中文数学符号
                    calc_expr = calc_expr.replace('加', '+').replace('减', '-')
                    calc_expr = calc_expr.replace('乘', '*').replace('除', '/')
                    # 安全地计算表达式
                    import math
                    result = eval(calc_expr, {'__builtins__': {}, 'math': math})
                    return f"计算结果: {result}"
                return "请说出要计算的表达式"
            except Exception as e:
                return f"计算错误: {str(e)}"
        
        return None
    
    def show_help(self):
        """显示帮助信息"""
        help_text = """📋 命令帮助信息 📋

🔊 语音模式使用说明:
• 首先说"电脑"唤醒语音助手
• 系统会通过声音和屏幕提示确认已听到
• 然后说出您的命令，例如："打开Chrome"或"查看系统信息"
• 提示：系统界面会显示监听状态，让您知道何时在听

💻 命令行模式使用说明:
• 直接输入命令并按回车
• 输入'voice'切换到语音模式
• 输入'exit'退出程序
• 输入'help'查看帮助

🚀 基础功能命令:
=== 应用控制 ===
打开Chrome      - 启动Chrome浏览器
打开记事本      - 启动记事本应用
打开命令提示符  - 启动命令行工具
关闭Chrome      - 关闭Chrome浏览器
关闭当前窗口    - 关闭活动窗口

=== 文件操作 ===
创建文件夹名为项目  - 创建指定名称的文件夹
查看当前目录      - 显示当前文件夹内容
搜索文件文档      - 搜索包含关键字的文件

=== 系统控制 ===
增大音量      - 提高系统音量
减小音量      - 降低系统音量
静音          - 开启/关闭静音
调高亮度      - 增加屏幕亮度
调低亮度      - 减小屏幕亮度

=== 系统信息 ===
查看系统信息  - 显示CPU、内存等信息

=== 系统操作 ===
关机          - 关闭计算机
重启电脑      - 重启计算机
睡眠模式      - 将电脑置于睡眠状态

✨ 增强功能命令:
• 截图/截屏: 捕获当前屏幕
• 计算器: 计算 2加3乘4
• 音乐播放: 播放音乐
• 提醒设置: 设置提醒

💡 提示:
• 语音识别可能受到环境噪音影响，请在安静环境下使用
• 命令表述尽量清晰简洁
• 系统已集成本地大模型，提供强大的自然语言理解能力
• 如需更强大的功能，可配置OpenAI API密钥"""
        print(help_text)


class SystemController:
    """系统控制器类，处理所有系统命令"""
    
    def __init__(self):
        self.applications = {
            "chrome": "chrome.exe",
            "记事本": "notepad.exe",
            "命令提示符": "cmd.exe",
            "命令行": "cmd.exe",
            "终端": "cmd.exe",
            "计算器": "calc.exe",
            "画图": "mspaint.exe",
            "资源管理器": "explorer.exe"
        }
    
    def execute_command(self, command, parameters=None):
        """执行系统命令"""
        if parameters is None:
            parameters = {}
        
        command_handlers = {
            "open_app": self._open_application,
            "close_app": self._close_application,
            "close_window": self._close_window,
            "system_info": self._get_system_info,
            "list_files": self._list_files,
            "search_files": self._search_files,
            "create_folder": self._create_folder,
            "volume_up": self._volume_up,
            "volume_down": self._volume_down,
            "mute": self._mute,
            "brightness_up": self._brightness_up,
            "brightness_down": self._brightness_down,
            "shutdown": self._shutdown,
            "restart": self._restart,
            "sleep": self._sleep,
            "screenshot": self._take_screenshot,
            "calculate": self._calculate,
            "play_music": self._play_music,
            "set_reminder": self._set_reminder
        }
        
        if command in command_handlers:
            return command_handlers[command](parameters)
        else:
            return f"未知命令: {command}"
    
    def _open_application(self, params):
        """打开应用程序"""
        app_name = params.get("app_name", "").lower()
        
        # 查找应用程序
        for key, exe in self.applications.items():
            if key in app_name:
                try:
                    subprocess.Popen([exe])
                    return f"已成功打开 {key}"
                except Exception as e:
                    return f"打开{key}失败: {str(e)}"
        
        # 如果找不到精确匹配，尝试直接运行
        try:
            subprocess.Popen([app_name])
            return f"已尝试打开 {app_name}"
        except Exception as e:
            return f"未找到应用程序: {app_name}"
    
    def _close_application(self, params):
        """关闭应用程序"""
        app_name = params.get("app_name", "").lower()
        
        # 查找应用程序
        for key, exe in self.applications.items():
            if key in app_name:
                try:
                    # 使用taskkill关闭进程
                    subprocess.run(["taskkill", "/F", "/IM", exe], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                    return f"已尝试关闭 {key}"
                except Exception as e:
                    return f"关闭{key}失败: {str(e)}"
        
        return f"未找到应用程序: {app_name}"
    
    def _close_window(self, params):
        """关闭当前窗口"""
        try:
            import pyautogui
            pyautogui.hotkey('alt', 'f4')
            return "已尝试关闭当前窗口"
        except ImportError:
            return "需要安装pyautogui库来关闭窗口"
        except Exception as e:
            return f"关闭窗口失败: {str(e)}"
    
    def _get_system_info(self, params):
        """获取系统信息"""
        try:
            import psutil
            
            # CPU信息
            cpu_percent = psutil.cpu_percent(interval=1)
            cpu_count = psutil.cpu_count(logical=True)
            
            # 内存信息
            memory = psutil.virtual_memory()
            memory_total = memory.total / (1024**3)
            memory_available = memory.available / (1024**3)
            memory_percent = memory.percent
            
            # 磁盘信息
            disk = psutil.disk_usage('/')
            disk_total = disk.total / (1024**3)
            disk_free = disk.free / (1024**3)
            
            # 系统信息
            import platform
            system_info = platform.uname()
            
            info = f"""=== 系统信息 ===
系统: {system_info.system} {system_info.release}
处理器: {cpu_count}核 CPU使用率: {cpu_percent}%
内存: 总计 {memory_total:.2f}GB, 可用 {memory_available:.2f}GB ({memory_percent}%)
磁盘: 总计 {disk_total:.2f}GB, 可用 {disk_free:.2f}GB
计算机名: {system_info.node}
系统类型: {system_info.machine}"""
            
            return info
        except ImportError:
            return "需要安装psutil库来获取系统信息"
        except Exception as e:
            return f"获取系统信息失败: {str(e)}"
    
    def _list_files(self, params):
        """列出文件"""
        path = params.get("path", ".")
        try:
            import os
            files = os.listdir(path)
            
            if not files:
                return f"目录 {path} 为空"
            
            result = f"目录 {path} 的内容:\n"
            folders = []
            regular_files = []
            
            for item in files:
                item_path = os.path.join(path, item)
                if os.path.isdir(item_path):
                    folders.append(f"📁 {item}")
                else:
                    size = os.path.getsize(item_path) / 1024  # KB
                    size_str = f" ({size:.1f}KB)" if size < 1024 else f" ({size/1024:.1f}MB)"
                    regular_files.append(f"📄 {item}{size_str}")
            
            if folders:
                result += "\n文件夹:\n" + "\n".join(folders)
            
            if regular_files:
                result += "\n\n文件:\n" + "\n".join(regular_files)
            
            return result
        except Exception as e:
            return f"列出文件失败: {str(e)}"
    
    def _search_files(self, params):
        """搜索文件"""
        keyword = params.get("keyword", "")
        path = params.get("path", ".")
        
        if not keyword:
            return "请提供搜索关键字"
        
        try:
            import os
            results = []
            
            for root, dirs, files in os.walk(path):
                # 限制搜索深度
                if root.count(os.sep) - path.count(os.sep) > 2:
                    continue
                
                for file in files:
                    if keyword.lower() in file.lower():
                        file_path = os.path.join(root, file)
                        relative_path = os.path.relpath(file_path, path)
                        size = os.path.getsize(file_path) / 1024  # KB
                        size_str = f" ({size:.1f}KB)" if size < 1024 else f" ({size/1024:.1f}MB)"
                        results.append(f"📄 {relative_path}{size_str}")
                
                for dir in dirs:
                    if keyword.lower() in dir.lower():
                        dir_path = os.path.join(root, dir)
                        relative_path = os.path.relpath(dir_path, path)
                        results.append(f"📁 {relative_path}")
            
            if not results:
                return f"未找到包含 '{keyword}' 的文件或文件夹"
            
            result = f"找到 {len(results)} 个匹配项:\n" + "\n".join(results[:20])
            if len(results) > 20:
                result += f"\n... 还有 {len(results) - 20} 个结果未显示"
            
            return result
        except Exception as e:
            return f"搜索文件失败: {str(e)}"
    
    def _create_folder(self, params):
        """创建文件夹"""
        folder_name = params.get("folder_name", "")
        
        if not folder_name:
            return "请提供文件夹名称"
        
        try:
            import os
            os.makedirs(folder_name, exist_ok=True)
            return f"文件夹 '{folder_name}' 创建成功"
        except Exception as e:
            return f"创建文件夹失败: {str(e)}"
    
    def _volume_up(self, params):
        """增大音量"""
        try:
            # 使用nircmd或Windows API调整音量
            # 这里使用简单的方法
            subprocess.run(["nircmd", "changesysvolume", "6553"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "音量已增加"
        except FileNotFoundError:
            # 如果没有nircmd，尝试使用其他方法
            try:
                # 使用PowerShell命令
                subprocess.run(["powershell", "(New-Object -ComObject WScript.Shell).SendKeys([char]175)"], 
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                return "音量已尝试增加"
            except Exception as e:
                return f"调整音量失败: {str(e)}"
    
    def _volume_down(self, params):
        """减小音量"""
        try:
            subprocess.run(["nircmd", "changesysvolume", "-6553"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "音量已减小"
        except FileNotFoundError:
            try:
                subprocess.run(["powershell", "(New-Object -ComObject WScript.Shell).SendKeys([char]174)"], 
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                return "音量已尝试减小"
            except Exception as e:
                return f"调整音量失败: {str(e)}"
    
    def _mute(self, params):
        """静音"""
        try:
            subprocess.run(["nircmd", "mutesysvolume", "2"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "静音状态已切换"
        except FileNotFoundError:
            try:
                subprocess.run(["powershell", "(New-Object -ComObject WScript.Shell).SendKeys([char]173)"], 
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                return "静音状态已尝试切换"
            except Exception as e:
                return f"切换静音失败: {str(e)}"
    
    def _brightness_up(self, params):
        """增加亮度"""
        try:
            # 使用PowerShell命令调整亮度
            subprocess.run(["powershell", "(Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightnessMethods).WmiSetBrightness(1, [math]::Min(100, (Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightness).CurrentBrightness + 10))"], 
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "屏幕亮度已增加"
        except Exception as e:
            return f"调整亮度失败: {str(e)}"
    
    def _brightness_down(self, params):
        """减小亮度"""
        try:
            subprocess.run(["powershell", "(Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightnessMethods).WmiSetBrightness(1, [math]::Max(0, (Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightness).CurrentBrightness - 10))"], 
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "屏幕亮度已减小"
        except Exception as e:
            return f"调整亮度失败: {str(e)}"
    
    def _shutdown(self, params):
        """关机"""
        try:
            # 添加确认
            confirm = params.get("confirm", False)
            if not confirm:
                return "关机命令需要确认，添加confirm参数并设置为true"
            
            subprocess.run(["shutdown", "/s", "/t", "30"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "系统将在30秒后关机"
        except Exception as e:
            return f"设置关机失败: {str(e)}"
    
    def _restart(self, params):
        """重启"""
        try:
            # 添加确认
            confirm = params.get("confirm", False)
            if not confirm:
                return "重启命令需要确认，添加confirm参数并设置为true"
            
            subprocess.run(["shutdown", "/r", "/t", "30"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "系统将在30秒后重启"
        except Exception as e:
            return f"设置重启失败: {str(e)}"
    
    def _sleep(self, params):
        """睡眠模式"""
        try:
            subprocess.run(["rundll32.exe", "powrprof.dll,SetSuspendState", "0,1,0"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            return "系统将进入睡眠模式"
        except Exception as e:
            return f"设置睡眠模式失败: {str(e)}"
    
    def _take_screenshot(self, params):
        """截图"""
        try:
            import pyautogui
            import time
            import os
            
            # 创建截图目录
            screenshot_dir = "screenshots"
            os.makedirs(screenshot_dir, exist_ok=True)
            
            # 截图
            filename = os.path.join(screenshot_dir, f"screenshot_{time.strftime('%Y%m%d_%H%M%S')}.png")
            screenshot = pyautogui.screenshot()
            screenshot.save(filename)
            
            return f"截图已保存到 {filename}"
        except ImportError:
            return "需要安装pyautogui库来进行截图"
        except Exception as e:
            return f"截图失败: {str(e)}"
    
    def _calculate(self, params):
        """计算"""
        expression = params.get("expression", "")
        
        if not expression:
            return "请提供计算表达式"
        
        try:
            # 替换中文数学符号
            expr = expression.replace('加', '+').replace('减', '-')
            expr = expr.replace('乘', '*').replace('除', '/')
            
            # 安全计算
            import math
            result = eval(expr, {'__builtins__': {}, 'math': math})
            
            return f"计算结果: {expression} = {result}"
        except Exception as e:
            return f"计算失败: {str(e)}"
    
    def _play_music(self, params):
        """播放音乐"""
        try:
            import webbrowser
            # 默认打开网易云音乐网页版
            webbrowser.open("https://music.163.com/")
            return "已打开网易云音乐"
        except Exception as e:
            return f"打开音乐播放器失败: {str(e)}"
    
    def _set_reminder(self, params):
        """设置提醒"""
        message = params.get("message", "")
        seconds = params.get("seconds", 0)
        
        if not message or seconds <= 0:
            return "请提供提醒消息和时间间隔"
        
        try:
            import threading
            import time
            
            def reminder_task():
                time.sleep(seconds)
                print(f"\n🔔 提醒: {message}")
                # 尝试播放提示音
                try:
                    import winsound
                    winsound.Beep(1000, 500)
                except:
                    pass
            
            # 启动提醒线程
            thread = threading.Thread(target=reminder_task)
            thread.daemon = True
            thread.start()
            
            minutes = seconds // 60
            seconds_remainder = seconds % 60
            time_str = f"{minutes}分钟{seconds_remainder}秒" if minutes > 0 else f"{seconds}秒"
            
            return f"已设置提醒，将在{time_str}后提醒您: {message}"
        except Exception as e:
            return f"设置提醒失败: {str(e)}"

def check_dependencies():
    """检查依赖是否已正确安装"""
    missing_deps = []
    try:
        import speech_recognition
    except ImportError:
        missing_deps.append("speech_recognition")
    
    try:
        import pyttsx3
    except ImportError:
        missing_deps.append("pyttsx3")
    
    try:
        import openai
    except ImportError:
        missing_deps.append("openai")
    
    try:
        import pyaudio
    except ImportError:
        missing_deps.append("pyaudio")
    
    # 检查可选依赖
    optional_deps = []
    try:
        import pyautogui
    except ImportError:
        optional_deps.append("pyautogui (用于截图功能)")
    
    print("🔍 依赖检查结果:")
    if missing_deps:
        print(f"⚠️  缺少必要依赖: {', '.join(missing_deps)}")
    else:
        print("✅ 所有必要依赖已安装")
    
    if optional_deps:
        print(f"ℹ️  缺少可选依赖: {', '.join(optional_deps)}")
        print("   这些功能仍可用，但某些高级功能可能受限")
    
    return missing_deps

# 主程序入口 - 升级版本
import json
import logging
import sys
import re
from datetime import datetime

# 导入新创建的模块
try:
    from voice_command_processor import command_processor
    print("✅ 语音命令处理器模块已加载")
except ImportError as e:
    print(f"⚠️  语音命令处理器模块加载失败: {e}")
    command_processor = None

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler("main.log", encoding='utf-8'),
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger("MainApp")

class CommandLineInterface:
    """命令行界面类，处理用户交互"""
    
    def __init__(self):
        """初始化命令行界面"""
        self.controller = SystemController()
        self.exit_commands = ['exit', 'quit', 'q', 'bye', 'exit()', 'quit()']
        self.help_commands = ['help', 'h', '?', '帮助', '命令', '可用命令']
    
    def print_welcome_message(self):
        """打印欢迎信息"""
        welcome = """
        ===================================================
                    系统控制中心 - 高级版
        ===================================================
        这是一个功能强大的系统控制工具，可以帮助您管理和控制计算机。
        输入 help 查看所有可用命令，输入 exit 退出程序。
        ===================================================
        """
        print(welcome)
    
    def print_help(self):
        """打印帮助信息"""
        help_text = """
        可用命令列表:
        
        🔹 应用程序控制:
          - open_app app_name=应用名称    打开指定应用程序
          - close_app app_name=应用名称  关闭指定应用程序
          - close_window                         关闭当前活动窗口
        
        🔹 文件操作:
          - list_files [path=路径]               列出文件和文件夹
          - search_files keyword=关键词 [path=路径] 搜索文件
          - create_folder folder_name=文件夹名称 [path=路径] 创建文件夹
        
        🔹 系统信息与控制:
          - system_info                      获取系统信息
          - shutdown delay=秒数 confirm=true      关闭计算机
          - restart delay=秒数 confirm=true       重启计算机
          - sleep                                进入睡眠模式
        
        🔹 媒体控制:
          - volume_up, volume_down, mute        控制音量
          - brightness_up, brightness_down      控制亮度
          - screenshot                           截图
          - play_music                           播放音乐
        
        🔹 实用工具:
          - calculate expression=表达式           计算表达式
          - set_reminder message=消息 seconds=秒数 设置提醒
        
        🔹 程序控制:
          - help, h, ?                           显示此帮助信息
          - exit, quit, q                        退出程序
        
        示例用法:
          1. 打开记事本: open_app app_name=记事本
          2. 搜索图片: search_files keyword=图片 path=d:\\
          3. 设置提醒: set_reminder message="喝水时间" seconds=120
          4. 关闭计算机(60秒后): shutdown delay=60 confirm=true
          5. 计算: calculate expression=2+3*4
        """
        print(help_text)
    
    def parse_command(self, user_input: str) -> tuple:
        """解析用户输入的命令
        
        Args:
            user_input: 用户输入的命令字符串
            
        Returns:
            (命令名称, 参数字典)
        """
        # 移除多余的空白字符
        user_input = re.sub(r'\s+', ' ', user_input.strip())
        
        # 分割命令和参数
        parts = user_input.split(' ', 1)
        command = parts[0].lower()
        params = {}
        
        # 解析参数
        if len(parts) > 1:
            # 使用正则表达式处理参数，支持包含空格的值
            param_pattern = r'(\w+)=("[^"]*"|\'[^\']*\'|[^\s]+)'
            matches = re.findall(param_pattern, parts[1])
            
            for key, value in matches:
                # 移除引号并去除首尾空白
                if (value.startswith('"') and value.endswith('"')) or \
                   (value.startswith('\'') and value.endswith('\'')):
                    value = value[1:-1].strip()
                
                # 尝试转换为布尔值
                if value.lower() == 'true':
                    params[key] = True
                elif value.lower() == 'false':
                    params[key] = False
                # 尝试转换为数字
                else:
                    try:
                        params[key] = int(value)
                    except ValueError:
                        try:
                            params[key] = float(value)
                        except ValueError:
                            # 保持为字符串
                            params[key] = value
        
        return command, params
    
    def run_interactive_mode(self):
        """运行交互式命令行模式"""
        self.print_welcome_message()
        
        while True:
            try:
                user_input = input("\n🔍 请输入命令 > ").strip()
                
                # 处理特殊命令
                if user_input.lower() in self.exit_commands:
                    print("👋 程序已退出。")
                    logger.info("程序已退出")
                    break
                elif user_input.lower() in self.help_commands:
                    self.print_help()
                    continue
                elif not user_input:
                    continue
                
                # 解析并执行命令
                command, params = self.parse_command(user_input)
                logger.info(f"执行命令: {command}, 参数: {params}")
                
                # 执行命令
                result = self.controller.execute_command(command, params)
                print("\n📋 执行结果:")
                print(result)
                
            except KeyboardInterrupt:
                print("\n\n👋 程序已退出。")
                logger.info("用户通过Ctrl+C退出程序")
                break
            except Exception as e:
                error_msg = f"❌ 发生错误: {str(e)}"
                print(error_msg)
                logger.error(f"执行命令时发生错误: {str(e)}")
    
    def run_command_mode(self, command: str, params_str: str = None):
        """运行单命令模式
        
        Args:
            command: 要执行的命令
            params_str: 参数字符串
        """
        try:
            # 解析参数
            params = {}
            if params_str:
                try:
                    # 尝试JSON格式
                    params = json.loads(params_str)
                except json.JSONDecodeError:
                    # 如果不是JSON格式，尝试键值对格式
                    command_line = f"{command} {params_str}"
                    _, params = self.parse_command(command_line)
            
            # 执行命令
            result = self.controller.execute_command(command, params)
            print(result)
            logger.info(f"单命令模式执行完成: {command}")
            return True
        except Exception as e:
            error_msg = f"❌ 执行命令时发生错误: {str(e)}"
            print(error_msg)
            logger.error(f"单命令模式执行失败: {str(e)}")
            return False

def main():
    """主函数"""
    try:
        # 检查Python版本
        if sys.version_info < (3, 7):
            print("❌ 错误: 需要Python 3.7或更高版本")
            sys.exit(1)
        
        # 检查依赖
        missing_deps = check_dependencies()
        if missing_deps:
            print(f"⚠️  警告: 缺少以下依赖包: {', '.join(missing_deps)}")
            print("   请运行 'pip install -r requirements.txt' 安装所需依赖")
            print("   部分功能可能无法正常使用")
        
        # 检查命令行参数
        if len(sys.argv) > 1 and sys.argv[1] in ["--cli", "-c"]:
            # 命令行模式（可选）
            cli = CommandLineInterface()
            if len(sys.argv) > 2:
                # 单命令模式
                command = sys.argv[2]
                params_str = ' '.join(sys.argv[3:]) if len(sys.argv) > 3 else None
                success = cli.run_command_mode(command, params_str)
                sys.exit(0 if success else 1)
            else:
                # 交互式模式
                cli.run_interactive_mode()
        else:
            # 默认启动语音模式
            print("🔄 正在初始化语音识别和大模型组件...")
            print("\n========================================")
            print("    语音对话电脑控制助手 - 高级版")
            print("========================================")
            print("这是一个功能强大的语音控制工具，可以通过语音命令控制您的计算机。")
            print(f"唤醒词: {WAKE_WORD}")
            print("========================================\n")
            
            # 导入VoiceAssistant
            assistant = VoiceAssistant()
            
            # 运行系统诊断
            print("\n🧙‍♂️ 运行快速配置检查...")
            assistant.run_diagnostic()
            
            # 启动语音助手
            print("\n🚀 准备启动语音助手...")
            assistant.start()
            
    except KeyboardInterrupt:
        print("\n👋 程序已退出")
    except Exception as e:
        logger.error(f"程序发生严重错误: {str(e)}")
        print(f"程序发生严重错误: {str(e)}")
        
        # 发生错误时，提供命令行模式作为备选
        try:
            print("\n🔄 尝试以命令行模式启动...")
            cli = CommandLineInterface()
            cli.run_interactive_mode()
        except Exception:
            print("\n无法启动任何模式，请检查错误信息")
            sys.exit(1)

if __name__ == "__main__":
    main()